home *** CD-ROM | disk | FTP | other *** search
/ CU Amiga Super CD-ROM 16 / CU Amiga Magazine's Super CD-ROM 16 (1997-10-16)(EMAP Images)(GB)[!][issue 1997-11].iso / CUCD / Graphics / Ghostscript / source / gdevmsxf.c < prev    next >
C/C++ Source or Header  |  1996-04-11  |  14KB  |  452 lines
  1. /* Copyright (C) 1993, 1994 Aladdin Enterprises.  All rights reserved.
  2.   
  3.   This file is part of Aladdin Ghostscript.
  4.   
  5.   Aladdin Ghostscript is distributed with NO WARRANTY OF ANY KIND.  No author
  6.   or distributor accepts any responsibility for the consequences of using it,
  7.   or for whether it serves any particular purpose or works at all, unless he
  8.   or she says so in writing.  Refer to the Aladdin Ghostscript Free Public
  9.   License (the "License") for full details.
  10.   
  11.   Every copy of Aladdin Ghostscript must include a copy of the License,
  12.   normally in a plain ASCII text file named PUBLIC.  The License grants you
  13.   the right to copy, modify and redistribute Aladdin Ghostscript, but only
  14.   under certain conditions described in the License.  Among other things, the
  15.   License requires that the copyright notice and this notice be preserved on
  16.   all copies.
  17. */
  18.  
  19. /* gdevmsxf.c */
  20. /* External font (xfont) implementation for Microsoft Windows. */
  21. #include "ctype_.h"
  22. #include "math_.h"
  23. #include "memory_.h"
  24. #include "string_.h"
  25. #include "gdevmswn.h"
  26. #include "gsutil.h"
  27. #include "gxxfont.h"
  28. #include "gsstruct.h"
  29.  
  30. /* Imported from gdevemap.c */
  31. extern const byte far_data gs_map_std_to_iso[256];
  32.  
  33. /* Declare the xfont procedures */
  34. private xfont_proc_lookup_font(win_lookup_font);
  35. private xfont_proc_char_xglyph(win_char_xglyph);
  36. private xfont_proc_char_metrics(win_char_metrics);
  37. private xfont_proc_render_char(win_render_char);
  38. private xfont_proc_release(win_release);
  39. private gx_xfont_procs win_xfont_procs = {
  40.     win_lookup_font,
  41.     win_char_xglyph,
  42.     win_char_metrics,
  43.     win_render_char,
  44.     win_release
  45. };
  46.  
  47. /* Return the xfont procedure record. */
  48. gx_xfont_procs *
  49. win_get_xfont_procs(gx_device *dev)
  50. {    return &win_xfont_procs;
  51. }
  52.  
  53. /* Define a Windows xfont. */
  54. typedef struct win_xfont_s win_xfont;
  55. struct win_xfont_s {
  56.     gx_xfont_common common;
  57.     LOGFONT lf;
  58.     TEXTMETRIC tm;
  59.     HFONT hFont;
  60.     gx_device_win *dev;                /* for GetDC */
  61.     int invert_y;
  62.     int y_offset;
  63. };
  64. gs_private_st_dev_ptrs1(st_win_xfont, win_xfont, "win_xfont",
  65.   win_xfont_enum_ptrs, win_xfont_reloc_ptrs, dev);
  66. #define wxf ((win_xfont *)xf)
  67.  
  68. /* Forward references */
  69. private HDC near win_get_dc(P1(gx_device_win *));
  70. private void near win_release_dc(P2(gx_device_win *, HDC));
  71. private int win_select_font(P2(HDC, win_xfont *));
  72.  
  73. /* Map from PostScript to Windows character codes. */
  74. /* (These tables were generated by winmaps.ps.) */
  75.  
  76. private const byte far_data gs_map_symbol_to_oem[256] = {
  77.   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  78.   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  79.   32, 33, 0, 35, 0, 37, 38, 0, 40, 41, 0, 43, 44, 0, 46, 47,
  80.   48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
  81.   0, 0, 0, 0, 0, 0, 231, 225, 0, 0, 0, 0, 0, 0, 0, 0,
  82.   226, 232, 0, 227, 0, 0, 0, 233, 0, 0, 0, 91, 0, 93, 0, 95,
  83.   0, 223, 224, 0, 234, 0, 236, 0, 0, 0, 0, 0, 0, 229, 0, 0,
  84.   0, 0, 0, 228, 230, 0, 0, 0, 0, 0, 0, 123, 124, 125, 0, 0,
  85.   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  86.   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  87.   0, 0, 0, 242, 0, 235, 0, 5, 4, 3, 6, 29, 27, 24, 26, 25,
  88.   247, 240, 0, 241, 0, 0, 0, 7, 245, 0, 239, 0, 0, 0, 0, 0,
  89.   0, 0, 0, 0, 0, 0, 0, 238, 0, 0, 0, 0, 0, 0, 237, 0,
  90.   0, 0, 0, 0, 0, 0, 250, 248, 169, 0, 0, 0, 0, 0, 0, 0,
  91.   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  92.   0, 0, 0, 243, 0, 244, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
  93. };
  94.  
  95. private const byte far_data gs_map_iso_to_oem[256] = {
  96.   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  97.   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  98.   32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 0, 46, 47,
  99.   48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
  100.   64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
  101.   80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95,
  102.   96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111,
  103.   112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 0,
  104.   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  105.   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  106.   32, 172, 154, 155, 0, 156, 0, 21, 0, 0, 165, 173, 169, 45, 0, 0,
  107.   247, 240, 252, 0, 0, 229, 20, 249, 0, 0, 166, 174, 171, 170, 0, 167,
  108.   0, 0, 0, 0, 141, 142, 145, 128, 0, 143, 0, 0, 0, 0, 0, 0,
  109.   0, 164, 0, 0, 0, 0, 152, 0, 0, 0, 0, 0, 153, 0, 0, 0,
  110.   133, 159, 131, 0, 132, 134, 144, 135, 138, 130, 136, 137, 140, 160, 0, 139,
  111.   0, 163, 148, 161, 146, 0, 147, 245, 0, 150, 162, 149, 129, 0, 0, 151
  112. };
  113.  
  114. /* Correlate PostScript font names with Windows font names. */
  115. /* This table should be an external resource, like Fontmap, */
  116. /* but that will have to wait till later. */
  117.  
  118. typedef struct font_entry_s {
  119.     const char _ds *key;
  120.     const char _ds *value;
  121.     uint pitchAndFamily;
  122. } font_entry;
  123.  
  124. private const font_entry font_names[] = {
  125.     {"Courier", "Courier New", FIXED_PITCH | FF_MODERN},
  126.     {"Helvetica", "Arial", VARIABLE_PITCH | FF_SWISS},
  127.     {"Helvetica", "Helv", VARIABLE_PITCH | FF_SWISS},
  128.     {"Times", "Times New Roman", VARIABLE_PITCH | FF_ROMAN},
  129.     {"Times", "Tms Rmn", VARIABLE_PITCH | FF_ROMAN}
  130. };
  131.  
  132. /* Look up a font. */
  133. private int /*bool*/ map_logical_font(P2(HDC, win_xfont *));
  134. gx_xfont *
  135. win_lookup_font(gx_device *dev, const byte *fname, uint len,
  136.   int encoding_index, const gs_uid *puid, const gs_matrix *pmat,
  137.   gs_memory_t *mem)
  138. {    win_xfont f;
  139.     win_xfont *wf;
  140.     uint name_len = min(len, LF_FACESIZE-1);
  141.     const font_entry _ds *pfe;
  142.     HDC hdc;
  143.     /* Only handle simple cases for now. */
  144.     if ( pmat->xy != 0 || pmat->yx != 0 || pmat->xx <= 0 ||
  145.          fabs(fabs(pmat->yy) - pmat->xx) > 0.00002
  146.        )
  147.         return NULL;
  148.     f.lf.lfHeight = pmat->xx * 1000;
  149.     /* Don't trust Windows with very small sizes. */
  150.     if ( f.lf.lfHeight < 6 || f.lf.lfHeight >= 36 )
  151.         return NULL;
  152.     f.lf.lfWidth = 0;
  153.     f.lf.lfEscapement = 0;
  154.     f.lf.lfOrientation = 0;
  155.     f.lf.lfWeight =
  156.         (string_match(fname, len, "*Bold*", 6, NULL) ?
  157.          FW_BOLD : FW_REGULAR);
  158.     f.lf.lfItalic =
  159.         string_match(fname, len, "*Italic*", 8, NULL) ||
  160.         string_match(fname, len, "*Oblique*", 9, NULL);
  161.     f.lf.lfUnderline = 0;
  162.     f.lf.lfStrikeOut = 0;
  163.     f.lf.lfCharSet =
  164.         (encoding_index == 2 ? SYMBOL_CHARSET : ANSI_CHARSET);
  165.     f.lf.lfOutPrecision = OUT_CHARACTER_PRECIS;
  166.     f.lf.lfClipPrecision = CLIP_STROKE_PRECIS;
  167.     f.lf.lfQuality = PROOF_QUALITY;
  168.     f.hFont = 0;
  169.     f.invert_y = pmat->yy >= 0;
  170.     hdc = win_get_dc(wdev);
  171.     if ( hdc == NULL )
  172.         return NULL;
  173.     for ( pfe = font_names; pfe != &font_names[countof(font_names)]; pfe++ )
  174.       if ( !strncmp(pfe->key, fname, strlen(pfe->key)) )
  175.     {    /* Found a match. */
  176.         strcpy(f.lf.lfFaceName, pfe->value);
  177.         f.lf.lfPitchAndFamily = pfe->pitchAndFamily;
  178.         if ( map_logical_font(hdc, &f) )
  179.             break;
  180.     }
  181.     if ( f.hFont == 0 )
  182.     {    /* No matches in the table, try with the given name. */
  183.         uint len;
  184.         memcpy(f.lf.lfFaceName, fname, name_len);    /* default */
  185.         for ( len = 0; len < name_len; len++ )
  186.           if ( !isalnum(fname[len]) )
  187.             break;
  188.         f.lf.lfFaceName[len] = 0;
  189.         f.lf.lfPitchAndFamily = 0;    /* default */
  190.         if ( !map_logical_font(hdc, &f) )
  191.         {    win_release_dc(wdev, hdc);
  192.             return NULL;
  193.         }
  194.     }
  195.     GetTextMetrics(hdc, &f.tm);
  196.     win_release_dc(wdev, hdc);
  197.     f.y_offset = (!f.invert_y ? f.tm.tmAscent : f.tm.tmDescent);
  198.     wf = gs_alloc_struct(mem, win_xfont, &st_win_xfont, "win_lookup_font");
  199.     if ( wf == 0 )
  200.     {    DeleteObject(f.hFont);
  201.         return NULL;
  202.     }
  203.     f.common.procs = &win_xfont_procs;
  204.     f.dev = wdev;
  205.     *wf = f;
  206.     return (gx_xfont *)wf;
  207. }
  208. /* Map the logical font, and see if the result is satisfactory. */
  209. private int /*bool*/
  210. map_logical_font(HDC hdc, win_xfont *xf)
  211. {    char szFaceName[LF_FACESIZE];
  212.     xf->hFont = CreateFontIndirect(&xf->lf);
  213.     if ( xf->hFont == 0 )
  214.         return 0;
  215.     /* Check the face name */
  216.     SelectObject(hdc, xf->hFont);
  217.     GetTextFace(hdc, sizeof(szFaceName), szFaceName);
  218.     if ( !strncmp(xf->lf.lfFaceName, szFaceName, strlen(xf->lf.lfFaceName)) )
  219.         return 1;
  220.     DeleteObject(xf->hFont);
  221.     xf->hFont = 0;
  222.     return 0;
  223. }
  224.  
  225. /* Convert a character name or index to an xglyph code. */
  226. gx_xglyph
  227. win_char_xglyph(gx_xfont *xf, gs_char chr, int encoding_index,
  228.   gs_glyph glyph, gs_proc_glyph_name_t glyph_name_proc)
  229. {    if ( chr == gs_no_char )
  230.         return gx_no_xglyph;    /* can't look up names yet */
  231.     if ( encoding_index == 0 )
  232.     {    /* Map StandardEncoding to ISOLatin1Encoding. */
  233.         /* We lose a couple of characters that exist in both */
  234.         /* StandardEncoding and the Windows OEM encoding but not in */
  235.         /* the ISOLatin1Encoding; we won't worry about this */
  236.         /* for now. */
  237.         chr = gs_map_std_to_iso[chr];
  238.         encoding_index = 1;
  239.     }
  240.     if ( wxf->hFont == NULL )
  241.     {    /* TEXTMETRICS not filled in yet */
  242.         HDC hdc = win_get_dc(wxf->dev);
  243.         int code;
  244.         if ( hdc == NULL )
  245.             return gx_no_xglyph;
  246.         code = win_select_font(hdc, wxf);
  247.         win_release_dc(wxf->dev, hdc);
  248.         if ( code < 0 )
  249.             return gx_no_xglyph;
  250.     }
  251.     switch ( wxf->tm.tmCharSet )
  252.     {
  253.     case ANSI_CHARSET:
  254.         if ( encoding_index == 1 && (chr < 0x7f || chr > 0x9f ||
  255.              chr == 0x91 || chr == 0x92)
  256.            )
  257.             break;
  258.         return gx_no_xglyph;
  259.     case OEM_CHARSET:
  260.         switch ( encoding_index )
  261.         {
  262.         case 1:                /* ISOLatin1 */
  263.             chr = gs_map_iso_to_oem[chr];
  264.             break;
  265.         case 2:                /* Symbol */
  266.             chr = gs_map_symbol_to_oem[chr];
  267.             break;
  268.         default:
  269.             return gx_no_xglyph;
  270.         }
  271.         break;
  272.     default:
  273.         return gx_no_xglyph;
  274.     }
  275.     return (chr != 0 && chr >= wxf->tm.tmFirstChar &&
  276.         chr <= wxf->tm.tmLastChar ?
  277.         (gx_xglyph)chr : gx_no_xglyph);
  278. }
  279.  
  280. /* Get the metrics for a character. */
  281. int
  282. win_char_metrics(gx_xfont *xf, gx_xglyph xg, int wmode,
  283.   gs_point *pwidth, gs_int_rect *pbbox)
  284. {    int code;
  285.     HDC hdc;
  286.     char chr = (char)xg;
  287.     if ( wmode != 0 )
  288.         return gs_error_undefined;
  289.     hdc = win_get_dc(wxf->dev);
  290.     if ( hdc == NULL )
  291.         return gs_error_limitcheck;
  292.     if ( (code = win_select_font(hdc, wxf)) < 0 )
  293.     {    win_release_dc(wxf->dev, hdc);
  294.         return code;
  295.     }
  296. #ifdef __WIN32__
  297.     {    SIZE sz;
  298.         GetTextExtentPoint(hdc, &chr, 1, &sz);
  299.         pwidth->x = sz.cx;
  300.     }
  301. #else
  302.     {    DWORD extent;
  303.           extent = GetTextExtent(hdc, &chr, 1);
  304.           pwidth->x = LOWORD(extent);
  305.     }
  306. #endif
  307.     win_release_dc(wxf->dev, hdc);
  308.     pwidth->y = 0;
  309.     pbbox->p.x = 0;
  310.     pbbox->q.x = pwidth->x;
  311.     if ( wxf->invert_y )
  312.     {    pbbox->p.y = -wxf->tm.tmDescent;
  313.         pbbox->q.y = wxf->tm.tmAscent;
  314.     }
  315.     else
  316.     {    pbbox->p.y = -wxf->tm.tmAscent;
  317.         pbbox->q.y = wxf->tm.tmDescent;
  318.     }
  319.     return 0;
  320. }
  321.  
  322. /* Render a character. */
  323. int
  324. win_render_char(gx_xfont *xf, gx_xglyph xg, gx_device *dev,
  325.   int xo, int yo, gx_color_index color, int required)
  326. {    char chr = (char)xg;
  327.     int code;
  328. #ifdef NOTUSED  /* we don't own any windows so we can no longer do this */
  329.     if ( dev->dname == gs_mswin_device.dname &&
  330.          wdev->hdctext != NULL && !wxf->invert_y
  331.        )
  332.     {    /* Display the character directly */
  333.         HDC hdc = wdev->hdctext;
  334.         PALETTEENTRY *pal = &wdev->limgpalette->palPalEntry[color];
  335.         if ( (code = win_select_font(hdc, wxf)) < 0 )
  336.             return code;
  337.         SetTextColor(hdc, RGB(pal->peRed, pal->peGreen, pal->peBlue));
  338.         SetBkMode(hdc, TRANSPARENT);
  339.         TextOut(hdc, xo, yo - wxf->y_offset, &chr, 1);
  340.     }
  341.     else
  342. #endif
  343.     if ( !required )
  344.         code = -1;        /* too hard */
  345.     else
  346.     {    /* Display on an intermediate bitmap, then copy the bits. */
  347.         gs_point wxy;
  348.         gs_int_rect bbox;
  349.         int w, h, wbm, raster;
  350.         gx_device_win *fdev = wxf->dev;
  351.         HBITMAP hbm;
  352.         byte *bits;
  353.         code = (*xf->common.procs->char_metrics)(xf, xg, 0,
  354.                              &wxy, &bbox);
  355.         if ( code < 0 )
  356.             return code;
  357.         w = bbox.q.x - bbox.p.x;
  358.         h = bbox.q.y - bbox.p.y;
  359.         wbm = round_up(w, align_bitmap_mod * 8);
  360.         raster = wbm >> 3;
  361.         bits = gs_malloc(h, raster, "win_render_char");
  362.         if ( bits == 0 )
  363.             return gs_error_limitcheck;
  364.         hbm = CreateBitmap(wbm, h, 1, 1, NULL);
  365.         if ( hbm == NULL )
  366.         {    code = gs_error_limitcheck;
  367.         }
  368.         else
  369.         {    HDC hdcwin = win_get_dc(fdev);
  370.             HDC hdcbit = CreateCompatibleDC(hdcwin);
  371.             dev_proc_copy_mono((*copy_mono)) =
  372.                 dev_proc(dev, copy_mono);
  373.             int y = yo - wxf->y_offset;
  374.             SetMapMode(hdcbit, GetMapMode(hdcwin));
  375.             win_select_font(hdcbit, wxf);
  376.             SelectObject(hdcbit, hbm);
  377.             PatBlt(hdcbit, 0, 0, wbm, h, rop_write_0s);
  378.             SetTextColor(hdcbit, 0xffffffL);    /* 1 */
  379.             SetBkMode(hdcbit, TRANSPARENT);
  380.             TextOut(hdcbit, 0, 0, &chr, 1);
  381.             GetBitmapBits(hbm, (DWORD)raster * h, bits);
  382.             DeleteDC(hdcbit);
  383.             win_release_dc(fdev, hdcwin);
  384.             DeleteObject(hbm);
  385.             if ( !wxf->invert_y )
  386.                 code = (*copy_mono)(dev, bits, 0,
  387.                         raster, gx_no_bitmap_id,
  388.                         xo, y, w, h,
  389.                         gx_no_color_index, color);
  390.             else
  391.             {    /* Copy scan lines in reverse order. */
  392.                 int i;
  393.                 y += h - 1;
  394.                 for ( i = 0; i < h; i++ )
  395.                     (*copy_mono)(dev, bits + i * raster,
  396.                         0, raster, gx_no_bitmap_id,
  397.                         xo, y - i, w, 1,
  398.                         gx_no_color_index, color);
  399.             }
  400.         }
  401.         gs_free(bits, h, raster, "win_render_char");
  402.     }
  403.     return (code < 0 ? code : 0);
  404. }
  405.  
  406. /* Release an xfont. */
  407. private int
  408. win_release(gx_xfont *xf, gs_memory_t *mem)
  409. {    if ( wxf->hFont )
  410.     {    DeleteObject(wxf->hFont);
  411.         wxf->hFont = 0;
  412.     }
  413.     if ( mem != NULL )
  414.         gs_free_object(mem, xf, "win_release");
  415.     return 0;
  416. }
  417.  
  418. /* ------ Font utilities ------ */
  419.  
  420. #undef wdev
  421. #undef wxf
  422.  
  423. /* Get a DC for the font's device. */
  424. private HDC near
  425. win_get_dc(gx_device_win *wdev)
  426. {    
  427.     /* Since we don't have a window, use the desktop */
  428.     /* Don't draw into it! */
  429.     return GetDC(HWND_DESKTOP);
  430. }
  431.  
  432. /* Release a DC for the font's device. */
  433. private void near
  434. win_release_dc(gx_device_win *wdev, HDC hdc)
  435. {    ReleaseDC(HWND_DESKTOP, hdc);
  436. }
  437.  
  438. /* Make an xfont current, possibly remapping it from a logical font. */
  439. private int
  440. win_select_font(HDC hdc, win_xfont *wxf)
  441. {    HFONT hFont = wxf->hFont;
  442.     if ( hFont == NULL )
  443.     {    /* The font was released to free up resources. */
  444.         /* Re-acquire it now. */
  445.         wxf->hFont = CreateFontIndirect(&wxf->lf);
  446.         if ( wxf->hFont == NULL )
  447.             return gs_error_limitcheck;
  448.     }
  449.     SelectObject(hdc, wxf->hFont);
  450.     return 0;
  451. }
  452.